#include <bits/stdc++.h>
using namespace std;

/*
  问题重述：
  给定 n 条线段 [l_i, r_i]，以及 m 个查询区间 [L_j, R_j]。
  若某条线段与查询区间的重叠长度 >= 该线段总长度的一半，则认为该线段被该区间“框住”。
  对每个查询区间，输出被它“框住”的线段数量。

  约定：n, m ≤ 1e5；所有 l_i, r_i, L_j, R_j 均在 [1, 1e6] 区间内；
  并且保证 max{r_i - l_i} ≤ min{R_j - L_j}，即每个查询区间长度不小于任何一条线段长度。
  
  既然查询区间长度 ≥ 任意线段长度，那么不可能出现“线段完全包裹查询区间两端”的情形。
  一条线段 [l, r] 与查询区间 [L, R] 的三种可能“框住方式”：
    1) 完全包含型：L ≤ l 且 r ≤ R。这时重叠长度 = (r - l)，显然 ≥ 一半长度。
    2) 左侧部分重叠：l < L ≤ r ≤ R，此时重叠长度 = r - L。需要 r - L ≥ (r - l)/2，
         化简得 2(r - L) ≥ r - l  ⇔  2r - 2L ≥ r - l  ⇔  r + l ≥ 2L  ⇔  L ≤ floor((l+r)/2)。
       同时要满足 r ≤ R。
    3) 右侧部分重叠：L ≤ l ≤ R < r，此时重叠长度 = R - l。需要 R - l ≥ (r - l)/2，
         化简得 2(R - l) ≥ r - l  ⇔ 2R - 2l ≥ r - l  ⇔ 2R ≥ r + l  ⇔  R ≥ ceil((l+r)/2)。
       同时要满足 l ≥ L。

  我们分别统计这三种情况的数量，然后对每个查询相加即可。
  
  三种情况分别的离线做法：
  （1）“完全包含型”：
      统计满足 l_i ≥ L_j 且 r_i ≤ R_j 的线段个数。
      经典做法：将所有线段按 l 从大到小排序；将所有查询按 L 从大到小排序。
      维护一个 Fenwick 树（BIT）记录目前已经“激活”的线段的 r 值：每插入一个线段 (l, r)，
      在 BIT[r] 加 1。这样，对于某条查询 (L, R)，我们先把所有 l_i ≥ L 的线段都插入 BIT，
      再在 BIT 上查询 [1..R] 的前缀和，即可得到满足 l_i ≥ L 且 r_i ≤ R 的线段数量。

  （2）“左侧部分重叠”：
      需满足 l_i < L_j ≤ r_i ≤ R_j 且 L_j ≤ floor((l_i + r_i)/2)。
      等价地，对每条线段 i，令 midL_i = floor((l_i + r_i)/2)。
      这条线段会被恰好那些 L ∈ [l_i+1, midL_i] 的查询在“左侧部分重叠”时计入，
      同时还要求 r_i ≤ R 查询。我们可以做一个“按 L 值”的扫描：
        - 先把所有线段展开成“增删”事件：当 L 从 1 开始往上扫，
          如果 t = l_i + 1，则在 r_i 位置插入 +1（表示从 L = l_i+1 开始，这条线段对满足 r ≥ r_i 的查询有贡献）；
          如果 t = midL_i + 1，则在 r_i 位置插入 -1（表示从 L = midL_i+1 开始，这条线段在“左侧部分重叠”条件下不再有效）。
        - 同时把所有查询 (L_j, R_j) 按 L_j 归类。扫描 L 从 1 到最大可能值（1e6），
          维护一个 Fenwick 树 BIT2 用来统计当前“依然活跃”的那些线段的 r_i。
          当到达时间 t 时，先处理所有事件：对 BIT2 在位置 r_i 做 +1 或 -1 更新；
          然后对所有 L_j = t 的查询，直接查询 BIT2 在区间 [1..R_j] 的前缀和，即得“左侧部分重叠”下
          满足 r_i ≤ R_j 且 L_j ∈ [l_i+1, midL_i] 的线段数。

  （3）“右侧部分重叠”：
      需满足 L_j ≤ l_i ≤ R_j < r_i 且 R_j ≥ ceil((l_i + r_i)/2)。
      令 midR_i = ceil((l_i + r_i)/2)。对于线段 i，当 R ∈ [midR_i, r_i - 1] 时，
      若且仅若 L ≤ l_i，就满足“右侧部分重叠”里对查询 (L, R) 的条件。于是：
        - 展开为“按 R 值”扫面：若 t = midR_i，则在 l_i 处插入 +1（从 R = midR_i 开始这条线段对满足 L ≤ l_i 的查询有贡献）；
          若 t = r_i，则在 l_i 处插入 -1（从 R = r_i 开始线段 i 已经不再“右侧部分重叠”，因为 R < r_i 必须成立，所以 R = r_i 时删去）。
        - 同时把所有查询 (L_j, R_j) 按 R_j 归类。扫描 R 从 1 到最大可能值（1e6），
          维护另一个 Fenwick 树 BIT3 用来统计当前“活跃”的那些线段的 l_i。
          到达时间 t 时，先处理所有事件：BIT3 在索引 l_i 做 +1 或 -1；
          然后对所有 R_j = t 的查询，直接在 BIT3 上查询区间 [L_j..MAX_COORD] 的后缀和即可，
          因为我们要数的是当前活跃的、且 l_i ≥ L_j 的线段。

最后将上述三种方式的计数相加，得到最终每个查询的答案。

下面的代码假定所有坐标都在 [1..MAXC] 范围内（MAXC = 1e6），Fenwick 数组都开到 MAXC+2。 
如果读者担心内存，可把 MAXC 调小到“实际出现的最大坐标”，但此处直接写成 1e6+5 比较简便。

*/

static const int MAXC = 1000000;  // 坐标上界
int n, m;

// 线段结构体：记录 l, r，以及 midL, midR
struct Segment {
    int l, r;
    int midL, midR;
};

// 查询结构体：记录 L, R，以及在三种统计里分别累加结果
struct Query {
    int L, R, idx;
    long long ans1, ans2, ans3;
};

vector<Segment> segs;
vector<Query> queries;

// Fenwick Tree (1-based)，支持点增、前缀和
struct Fenwick {
    int N;
    vector<int> tree;
    Fenwick(int _N) : N(_N), tree(N+1, 0) {}

    // 在位置 x 上加 v
    void update(int x, int v) {
        for (; x <= N; x += x & -x) {
            tree[x] += v;
        }
    }
    // 计算 1..x 的前缀和
    int query(int x) const {
        int s = 0;
        for (; x > 0; x -= x & -x) {
            s += tree[x];
        }
        return s;
    }
    // 计算 [l..r] 的区间和
    int query_range(int l, int r) const {
        if (l > r) return 0;
        return query(r) - query(l-1);
    }
};

// 全局 Fenwicks（注意：它们会重复利用不同阶段）
Fenwick *BIT1, *BIT2, *BIT3;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> n >> m;
    segs.resize(n);
    for(int i = 0; i < n; i++) {
        int l, r;
        cin >> l >> r;
        segs[i].l = l;
        segs[i].r = r;
        // floor((l+r)/2)
        segs[i].midL = (l + r) / 2;
        // ceil((l+r)/2) = (l+r+1)/2
        segs[i].midR = (l + r + 1) / 2;
    }

    queries.resize(m);
    for(int i = 0; i < m; i++){
        cin >> queries[i].L >> queries[i].R;
        queries[i].idx = i;
        queries[i].ans1 = queries[i].ans2 = queries[i].ans3 = 0;
    }

    // =============================
    // （1）统计“完全包含型”： l_i ≥ L_j 且 r_i ≤ R_j
    // =============================
    // 按 l 从大到小把线段索引排序
    vector<int> orderSeg(n);
    iota(orderSeg.begin(), orderSeg.end(), 0);
    sort(orderSeg.begin(), orderSeg.end(), [&](int a, int b){
        return segs[a].l > segs[b].l;
    });
    // 按 L 从大到小把查询排序
    vector<int> orderQ1(m);
    iota(orderQ1.begin(), orderQ1.end(), 0);
    sort(orderQ1.begin(), orderQ1.end(), [&](int a, int b){
        return queries[a].L > queries[b].L;
    });

    // Fenwick 用来记录“已插入”的线段 r 值
    BIT1 = new Fenwick(MAXC+2);
    int ptr = 0;  
    // 遍历每个查询（L 从大到小），把所有 l_i ≥ L 的线段插入
    for(int qi : orderQ1){
        int Lq = queries[qi].L;
        int Rq = queries[qi].R;
        // 插入所有 segs[orderSeg[ptr]] 中 l >= Lq 的线段
        while(ptr < n && segs[orderSeg[ptr]].l >= Lq){
            int ridx = segs[orderSeg[ptr]].r;
            BIT1->update(ridx, 1);
            ptr++;
        }
        // 此时 Fenwick 里恰好记录了所有 l_i ≥ Lq 的线段。在这些线段里，
        // 询问 r ≤ Rq 的数量 = 前缀和 query(Rq)
        queries[qi].ans1 = BIT1->query(Rq);
    }

    // =============================
    // （2）统计“左侧部分重叠”：
    //      条件：l_i < L_j ≤ r_i ≤ R_j 且 L_j ≤ midL_i
    //      等价：L ∈ [l_i+1, midL_i]，并且 r_i ≤ R
    //      做法：对每条线段 i，产生两个事件：
    //           （a）t = l_i + 1 时在 r_i 上加 +1；
    //           （b）t = midL_i + 1 时在 r_i 上加 -1。
    //      在 L 从 1..MAXC 扫描时，维护一个 Fenwick BIT2 存活地记录
    //      这些“当前 L 下活跃”线段在 r 轴上的 +1 累加。每当有查询 L_j = t 时，
    //      它的贡献 = BIT2.query(R_j)（即统计所有当前活跃的、且 r_i ≤ R_j 的线段）。

    // 构造按 L 值分组的查询下标
    vector<vector<int>> qsByL(MAXC+2);
    for(int i = 0; i < m; i++){
        qsByL[queries[i].L].push_back(i);
    }

    // 构造事件：E1[t] 存放所有在“L = t”时要对 BIT2 做的更新 (r_i, delta)
    vector<vector<pair<int,int>>> E1(MAXC+2);
    for(int i = 0; i < n; i++){
        int l = segs[i].l;
        int r = segs[i].r;
        int mL = segs[i].midL;
        int start = l + 1;      // 从 L = l+1 开始这条“线段 i”有可能“左侧部分重叠”
        int end   = mL + 1;     // 从 L = mL+1 开始就超出“L ≤ midL_i”的范围，应当删除
        if(start <= mL) {
            // 在 t = start 时加入 +1，在 t = end 时加 -1
            E1[start].push_back({ r, +1 });
            if(end <= MAXC) {
                E1[end].push_back({ r, -1 });
            }
        }
    }

    BIT2 = new Fenwick(MAXC+2);
    // 从 L = 1..MAXC 依次扫描
    for(int L = 1; L <= MAXC; L++){
        // 先处理所有在“L”时刻发生的事件，对 r_i 做 +1 / -1
        for(auto &ev : E1[L]){
            int rpos = ev.first;
            int delta = ev.second;
            BIT2->update(rpos, delta);
        }
        // 然后处理所有恰好 L_j = L 的查询
        for(int qi : qsByL[L]){
            int Rq = queries[qi].R;
            // 统计当前活跃的线段中，满足 r_i ≤ Rq 的个数
            queries[qi].ans2 = BIT2->query(Rq);
        }
    }

    // =============================
    // （3）统计“右侧部分重叠”：
    //      条件：L_j ≤ l_i ≤ R_j < r_i 且 R_j ≥ midR_i
    //      等价：R ∈ [midR_i, r_i - 1]，并且 L ≤ l_i。
    //      做法：对每条线段 i，产生事件：
    //         （a）t = midR_i 时在 l_i 上加 +1；
    //         （b）t = r_i    时在 l_i 上加 -1。
    //      用 Fenwick BIT3 存储当前“活跃”线段的 l_i。扫描 R = 1..MAXC，
    //      每当到达时间 t，就按事件更新 BIT3；然后对所有 R_j = t 的查询，计算
    //      BIT3.query_range(L_j, MAXC)（即统计所有活跃的且 l_i ≥ L_j 的线段数）。

    // 按 R 值把查询分组
    vector<vector<int>> qsByR(MAXC+2);
    for(int i = 0; i < m; i++){
        qsByR[queries[i].R].push_back(i);
    }

    // 构造事件 E2[t] 存放在 R = t 时需要对 BIT3 做的更新 (l_i, delta)
    vector<vector<pair<int,int>>> E2(MAXC+2);
    for(int i = 0; i < n; i++){
        int l = segs[i].l;
        int r = segs[i].r;
        int mR = segs[i].midR;
        int start = mR;    // 从 R = midR_i 开始线段 i 可能“右侧部分重叠”
        int end   = r;     // R = r_i 时“必须”删除它，因为需要 R < r_i 才算重叠
        if(start <= r-1) {
            // 在 R = start 时加入 +1，在 R = end 时加入 -1
            E2[start].push_back({ l, +1 });
            if(end <= MAXC) {
                E2[end].push_back({ l, -1 });
            }
        }
    }

    BIT3 = new Fenwick(MAXC+2);
    // 从 R = 1..MAXC 扫描
    for(int R = 1; R <= MAXC; R++){
        // 先处理 E2[R] 里所有 (l_i, delta)
        for(auto &ev : E2[R]){
            int lpos = ev.first;
            int delta = ev.second;
            BIT3->update(lpos, delta);
        }
        // 再处理所有 R_j = R 的查询
        for(int qi : qsByR[R]){
            int Lq = queries[qi].L;
            // 查询所有活跃线段中，l_i ≥ Lq 的个数
            queries[qi].ans3 = BIT3->query_range(Lq, MAXC);
        }
    }

    // =============================
    // 合并三部分结果并输出
    // =============================
    vector<long long> answer(m);
    for(int i = 0; i < m; i++){
        long long total = queries[i].ans1 + queries[i].ans2 + queries[i].ans3;
        answer[ queries[i].idx ] = total;
    }
    for(int i = 0; i < m; i++){
        cout << answer[i] << "\n";
    }
    return 0;
}
